package main

/*
K个一组翻转链表

给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。
k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。
你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

示例 1：
输入：head = [1,2,3,4,5], k = 2
输出：[2,1,4,3,5]

示例 2：
输入：head = [1,2,3,4,5], k = 3
输出：[3,2,1,4,5]

*/

import "fmt"

type ListNode struct {
	Val  int
	Next *ListNode
}

func reverseKGroup(head *ListNode, k int) *ListNode {
	hair := &ListNode{Next: head}
	pre := hair

	for head != nil {
		tail := pre
		for i := 0; i < k; i++ {
			tail = tail.Next
			if tail == nil {
				return hair.Next
			}
		}
		nex := tail.Next
		head, tail = myReverse(head, tail)
		pre.Next = head
		tail.Next = nex
		pre = tail
		head = tail.Next
	}
	return hair.Next
}

func myReverse(head, tail *ListNode) (*ListNode, *ListNode) {
	prev := tail.Next
	p := head
	for prev != tail {
		nex := p.Next
		p.Next = prev
		prev = p
		p = nex
	}
	return tail, head
}

//从末尾添加元素
func AddNode(head *ListNode, data *ListNode) {
	temp := head
	for {
		if temp.Next == nil {
			break
		}
		temp = temp.Next
	}
	temp.Next = data
}

//显示全部链表
func ShowNode(head *ListNode) {
	temp := head
	//判断是否为空
	if temp.Next == nil {
		fmt.Println("error:node is nil")
		return
	}
	//遍历链表
	for {
		fmt.Printf("%v", temp.Val)
		temp = temp.Next
		if temp.Next == nil {
			break
		}
	}
}

func main() {
	//创造头节点
	head := &ListNode{}
	//创造新元素
	n1 := &ListNode{
		Val: 2,
	}
	n2 := &ListNode{
		Val: 4,
	}
	n3 := &ListNode{
		Val: 1,
	}
	n4 := &ListNode{
		Val: 9,
	}
	n5 := &ListNode{
		Val: 9,
	}

	//加入
	AddNode(head, n1)
	AddNode(head, n2)
	AddNode(head, n3)
	AddNode(head, n4)
	AddNode(head, n5)
	// //显示
	// ShowNode(head)
	fmt.Println(reverseKGroup(n1, 2))
}
